In the past, handheld computer devices were often single-function or of relatively limited functionality. For example, many of us carried mobile telephones that performed a relatively limited number of functions built into the phone at time of manufacture. In addition to making phone calls, it was possible to bring up a contact list, a calendar and perhaps play a game or two. However, the functionality was generally not expandable.
Modern handheld devices are a different story. With the availability of high-bandwidth data communications over wireless networks, it has now become possible to download new functionality onto handheld devices at any time, long after the devices have been released into the field and are in the hands of consumers. Entire businesses are based on developing new handheld applications—software modules that can be downloaded wirelessly on demand into a handheld device to perform desired functions. Some users have downloaded literally hundreds of applications onto their handheld devices. Organizing all of these applications into selectable menus can be a challenge.
One way to organize menu items is manually. Many of us have used interfaces that allow us to move icons associated with different applications around on the user interface using a pointing device such as a mouse, a stylus or even a finger in contact with a touch screen. Some devices permit users to move such icons across pages and to bring up different pages depending on which applications are desired. For example, a first menu page could be used to contain the most important applications the user uses every day. A second page might be used to organize icons the user uses less frequently. Still a third page might contain icons the user evokes only occasionally. Manually organizing the icons or buttons on these different pages can work well when there is a relatively limited number of items to organize and keep track of. Manual operations become more challenging when the number of items increases.
One way to organize a larger number of items is to sort them according to sort criteria. Every time we bring home groceries we sort the items based on where they are to be stored. Items requiring refrigeration are placed into the refrigerator. Canned items may be sorted into one cupboard, and dry goods into another.
Computers are very good at automatically sorting data items based on information such as for example alphabetic name order, most recent, author, type or the like. Although algorithms computers use to sort data are generally well-known, applying such algorithms to user interface items can be a challenge. For example, the user may become frustrated if an item she was looking at on one menu page “disappears” as a result of the sort because it was moved to a different page. Therefore, further improvements are possible.
In one exemplary illustrative non-limiting implementation, items such as software objects are downloadable onto a handheld or other computing device. Such items are presented on menu pages for selection by the user. Depending on the number of items that are downloaded, it may be necessary or desirable to display such items on more than one menu page. The handheld is capable of sorting these downloaded items based on a variety of sort criteria such as for example most used, most recent, author, creation date, type, alphabetic name, etc.
In an exemplary illustrative non-limiting implementation, sorts are performed not just on the items currently visible, but across multiple pages or parts of pages some of which may not be currently visible. In one exemplary illustrative non-limiting implementation, all pages are virtually joined in the same data storage “bucket.” Sorts performed by the computer may thus be applied across multiple pages some of which are currently visible and some of which may not be. By sorting displayed information, the sort criteria can be applied across and maintained across multiple other pages. In this way, the user sees expected functionality on the page she is currently viewing, and the computer works behind the scenes to consistently sort other items currently hidden from view so that when the user selects those pages they will already have been similarly sorted in a coherent manner.
In exemplary illustrative non-limiting implementations, the sort may be performed based on a variety of criteria such as for example, latest, size, name, level, author/creator or other criteria. In some exemplary implementations, a “shuffle” functionality may be provided to re-sort menu items based on random or pseudo-random criteria. When the user sorts the items presented on a given page, the system can automatically apply that same sorting criteria to a larger set of items that may be displayed on different pages so that the order across multiple pages (some of which may be hidden at any given time) is consistent. In this way, the user is more easily able to navigate across multiple pages and finds items in those multiple pages sorted in a consistent manner. Additionally, the user is dynamically able to re-sort the items at any time and the re-sorting will once again be applied consistently across multiple pages of items.
Other non-limiting features and advantages include:
The more data displayed at one time, the more precision may be needed to navigate and select it. Because we have multiple pages, we are going to sort all of that data—even data that is not currently visible.
Lists are divided into chunks for easier navigability.
Each sort will sort all entries.
When sorting, the user stays on a given page but the data could be changed. Sorting changes the data being displayed as well as data that is hidden, rather than simply sorting the data currently being displayed.
Sorting mechanism is not restricted to the current page.
Global sort that is not restricted to the current page.
Scrolling list is a combination of sorted data and paging as well as a slider.
The buttons scroll based on movement of the slider.
There can be a detailed description behind the button (e.g., rating, high score, etc.).
Selecting an item can activate the icon to start the application.
A scroll box can be used to scroll the buttons or other items.
The less data in in the list, the slower the interface will scroll from top to bottom based on user manipulation of the slider
Scrolling can be performed on one page of data at a time.
The items can be presorted by the server before download in order to maximize efficiency on the handheld device. Thus, part of the sort can be performed on the server, and another part of the sort can be performed on the handheld device after download. In other implementations, all sorting is performed on the handheld device.
When an item is selected, the selection remains where it is on the screen. Thus, the buttons are recycled in order to ensure memory efficiency. The buttons can be static, and the data stored in association with the buttons can be changed. The data is populated dynamically as one scrolls through the list.
The list can be endless, constrained only by the memory resources available on the handheld device.
Scrolling speed may be determined by the length of the list. Button height×number of buttons determines a ratio of how many pixels on the slider do we need to represent in the window in order to make it to the bottom of the list. The ratio determines how fast the slider scrolls the list. Faster scrolling will result from more items on the list, slower scrolling will result from fewer items on the list.
The slider may be configured to provide sufficient resolution to allow the user to control it to reach a desired item on the list.
The touch screen resolution may be in pixel values. When the touch screen is touched, the output is thus typically in whole numbers. Accordingly, the slider is designed to move in at least one-pixel increments.
In one example implementation, the height of the button is 32 pixels, so the slider height should be divisible by 32. The amount of data to display on the buttons can also determine the size of the buttons, which determines the scrolling resolution.
Can be used for any type of data format to present to the user, for example friends list or any other collection of items. Any type of data that can be arranged could be used.
It is possible to give the user level information based on user information, e.g., data that is linked to the user identification.
Paging breaks up long lists into shorter, more navigable lists.
Random levels can be downloaded and used.